package com.example.controller;

import com.example.common.PageResult;
import com.example.common.Result;
import com.example.entity.Login;
import com.example.entity.User;
import com.example.service.UserService;
import org.springframework.web.bind.annotation.*;

import javax.annotation.Resource;
import javax.servlet.http.HttpSession;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * 用户控制器
 */
@RestController
@RequestMapping("/api/user")
public class UserController {

    @Resource
    private UserService userService;

    /**
     * 获取用户列表
     *
     * @param pageNum  页码
     * @param pageSize 每页数量
     * @return 用户列表
     */
    @GetMapping("/list")
    public Result<PageResult<User>> list(
            @RequestParam(value = "pageNum", defaultValue = "1") Integer pageNum,
            @RequestParam(value = "pageSize", defaultValue = "10") Integer pageSize) {
        // 计算偏移量
        int offset = (pageNum - 1) * pageSize;
        // 查询用户列表
        List<User> users = userService.queryAllByLimit(offset, pageSize);
        // 查询总记录数
        long total = userService.countUsers();
        // 返回分页结果
        return PageResult.restPage(pageNum, pageSize, total, users);
    }

    /**
     * 获取用户详情
     *
     * @param id 用户ID
     * @return 用户详情
     */
    @GetMapping("/detail/{id}")
    public Result<User> detail(@PathVariable("id") Long id) {
        User user = userService.queryById(id);
        if (user != null) {
            // 出于安全考虑，不返回密码
            user.setPassword(null);
            return Result.success(user);
        } else {
            return Result.error("用户不存在");
        }
    }

    /**
     * 更新用户信息
     *
     * @param user 用户信息
     * @return 更新结果
     */
    @PutMapping("/update")
    public Result<User> update(@RequestBody User user) {
        if (user.getId() == null) {
            return Result.validateFailed("用户ID不能为空");
        }
        User updatedUser = userService.update(user);
        // 出于安全考虑，不返回密码
        updatedUser.setPassword(null);
        return Result.success(updatedUser);
    }

    /**
     * 添加用户
     *
     * @param user 用户信息
     * @return 添加结果
     */
    @PostMapping("/add")
    public Result<User> add(@RequestBody User user) {
        User existUser = userService.queryAll(new User()).stream()
                .filter(u -> user.getUsername().equals(u.getUsername()))
                .findFirst()
                .orElse(null);
        if (existUser != null) {
            return Result.error("用户名已存在");
        }
        User insertedUser = userService.insert(user);
        // 出于安全考虑，不返回密码
        insertedUser.setPassword(null);
        return Result.success(insertedUser);
    }

    /**
     * 删除用户
     *
     * @param id 用户ID
     * @return 删除结果
     */
    @DeleteMapping("/delete/{id}")
    public Result<Boolean> delete(@PathVariable("id") Long id) {
        boolean result = userService.deleteById(id);
        if (result) {
            return Result.success(true);
        } else {
            return Result.error("删除失败");
        }
    }

    /**
     * 用户登录
     *
     * @param session  会话
     * @return 登录结果
     */
    @PostMapping("/login")
    public Result<Map<String, Object>> login(
            @RequestBody Login login,
            HttpSession session) {
        User user = userService.login(login.getUsername(), login.getPassword());
        if (user != null) {
            // 登录成功，将用户信息存入session
            session.setAttribute("user", user);
            
            // 返回用户信息和token（这里简单使用sessionId作为token）
            Map<String, Object> data = new HashMap<>();
            // 出于安全考虑，不返回密码
            user.setPassword(null);
            data.put("user", user);
            data.put("token", session.getId());
            
            return Result.success("登录成功", data);
        } else {
            return Result.error("用户名或密码错误");
        }
    }

    /**
     * 用户退出登录
     *
     * @param session 会话
     * @return 退出结果
     */
    @PostMapping("/logout")
    public Result<Boolean> logout(HttpSession session) {
        // 清除session中的用户信息
        session.removeAttribute("user");
        return Result.success(true);
    }

    /**
     * 用户注册
     *
     * @param user 用户信息
     * @return 注册结果
     */
    @PostMapping("/register")
    public Result<User> register(@RequestBody User user) {
        boolean result = userService.register(user);
        if (result) {
            // 注册成功，返回用户信息
            // 出于安全考虑，不返回密码
            user.setPassword(null);
            return Result.success("注册成功", user);
        } else {
            return Result.error("用户名已存在");
        }
    }

    /**
     * 检查用户名是否存在
     *
     * @param username 用户名
     * @return 检查结果
     */
    @GetMapping("/checkUsername")
    public Result<Boolean> checkUsername(@RequestParam String username) {
        User user = userService.queryAll(new User()).stream()
                .filter(u -> username.equals(u.getUsername()))
                .findFirst()
                .orElse(null);
        return Result.success(user != null);
    }
    
    /**
     * 获取当前登录用户信息
     *
     * @param session 会话
     * @return 当前用户信息
     */
    @GetMapping("/current")
    public Result<User> getCurrentUser(HttpSession session) {
        User user = (User) session.getAttribute("user");
        if (user != null) {
            // 重新查询最新的用户信息
            user = userService.queryById(user.getId());
            // 出于安全考虑，不返回密码
            user.setPassword(null);
            return Result.success(user);
        } else {
            return Result.unauthorized();
        }
    }
}